Amiga Tools 5/Amiga Tools 5.iso/grafik/converter/limbo4.0/src/3d/allocate.c

C/C++ Source or Header | 1996-07-16 | 16.1 KB | 557 lines

#include "includes.h"

/**************************************|****************************************
Routine   : GimmeAPoolNode
Input  par: none
Output par: PoolNode * (pointer to PoolNode)
Function  : Allocates a PoolNode structure. Initializes Next in
            structure PoolNode to zero.
***************************************|***************************************/

 PoolNode *GimmeAPoolNode(void)
  {
   PoolNode *p=(PoolNode *)malloc(sizeof(PoolNode));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNode not able to allocate structure");
   p->x=p->y=p->z=0;
   p->Features=NULL; /* initialize */
   p->Distance=NULL;
   p->Index=NULL;
   p->Next=NULL;
   return p;
  }

/**************************************|****************************************
Routine   : FreeMeAPoolNode"
Input  par: PoolNode *El (pointer to PoolNode)
Output par: none
Function  : Frees a PoolNode structure.
***************************************|***************************************/

 void FreeMeAPoolNode(PoolNode *p)
  {
   if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAPoolNode with null pointer");
   free(p);
  }

/**************************************|****************************************
Routine   : GimmeAPoolStructure"
Input  par: none
Output par: PoolStructure * (pointer to PoolStructure)
Function  : Allocates a PoolStructure. Initializes pointers to Edges,
            Shadesto null and B, D = 0.
***************************************|***************************************/

 PoolStructure *GimmeAPoolStructure(void)
  {
   PoolStructure *p=(PoolStructure *)malloc(sizeof(PoolStructure));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolStructure not able to allocate structure");
   p->DomainNodes=p->RangeNodes=NULL;
   p->Next=NULL;
   p->D=p->B=0;
   return p;
  }

/**************************************|****************************************
Routine   : FreeMeAPoolStructure"
Input  par: PoolStructure *p (pointer to PoolStructure)
Output par: none
Function  : Frees a PoolStructure.
***************************************|***************************************/

 void FreeMeAPoolStructure(PoolStructure *p)
  {
   if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAPoolStructure with null pointer");
   free(p);
  }

/**************************************|****************************************
Routine   : GimmeAPoolNodeArray"
Input  par: int xsize (x size of PoolNodearray)
            int ysize (y size of PoolNodearray)
Output par: PoolNode ***  (pointer to 2D array of PoolNode-pointers)
Function  : Allocates a 2D structure of Poolnodes. No Initializing.
***************************************|***************************************/

 PoolNode ****GimmeAPoolNodeArray3D(int xsize,int ysize,int zsize)
  {
   int i,j;
   PoolNode ****Array;

   Array=(PoolNode ****) calloc(xsize,sizeof(PoolNode ***));
   if (Array==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNodeArray3D not able to allocate struture");
   for (i=0;i<xsize;i++)
    {
     Array[i]=(PoolNode ***) calloc(ysize,sizeof(PoolNode **));
     if (Array[i]==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNodeArray3D not able to allocate structure");
     for (j=0;j<ysize;j++)
      {
       Array[i][j]=(PoolNode **) calloc(zsize,sizeof(PoolNode *));
       if (Array[i][j]==NULL)
       ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNodeArray3D not able to allocate structure");
      }
    }
   return Array;
  }

/**************************************|****************************************
Routine   : FreeMeAPoolNodeArray"
Input  par: PoolArray *p (pointer to PoolNodeArray)
            int xsize    (xsize of array)
Output par: none
Function  : Frees a PoolNodeArray Node.
***************************************|***************************************/

 void FreeMeAPoolNodeArray3D(PoolNode ****p,int xsize,int ysize)
  {
   register unsigned int i,j;

   if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAPoolNodeArray3D with null pointer");
   for (i=0;i<xsize;i++)
    {
     for (j=0;j<ysize;j++) free(p[i][j]);
     free(p[i]);
    }
   free(p);
  }

/**************************************|****************************************
Routine   : GimmeATransformation"
Input  par: none
Output par: Transformation * (pointer to Transformation)
Function  : Allocates a Transformation structure. Initializes Domain and Sub.
***************************************|***************************************/

 Transformation *GimmeATransformation(void)
  {
   Transformation *p=(Transformation *)malloc(sizeof(Transformation));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeATransformation not able to allocate structure");
   p->Domain=NULL; /* initialize */
   p->Sub=NULL;
   return p;
  }

/**************************************|****************************************
Routine   : FreeMeATransformation"
Input  par: Transformation *Tr (pointer to Transformation)
Output par: none
Function  : Frees a Transformation structure.
***************************************|***************************************/

 void FreeMeATransformation(Transformation *Tr)
  {
   if (Tr==NULL) ErrorHandler(NULL_POINTER,"FreeMeATransformation with null pointer");
   free(Tr);
  }

/**************************************|****************************************
Routine   : GimmeATransArray"
Input  par: int xsize (x size of transarray)
            int ysize (y size of transarray)
Output par: Transformation *** (pointer to 2D array of transformation-pointers)
Function  : Allocates a 2D structure of transformationpointers. No Initializing.
***************************************|***************************************/


 Transformation ****GimmeATransArray3D(int xsize,int ysize,int zsize)
  {
   int i,j;
   Transformation ****Array;

   Array=(Transformation ****) calloc(xsize,sizeof(Transformation ***));
   if (Array==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeATransArray3D not able to allocate struture");
   for (i=0;i<xsize;i++)
    {
     Array[i]=(Transformation ***) calloc(ysize,sizeof(Transformation **));
     if (Array[i]==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeATransArray3D not able to allocate structure");
     for (j=0;j<ysize;j++)
      {
       Array[i][j]=(Transformation **) calloc(zsize,sizeof(Transformation *));
       if (Array[i][j]==NULL)
       ErrorHandler(NO_FREE_MEMORY,"GimmeATransArray3D not able to allocate structure");
      }
    }
   return Array;
  }

/**************************************|****************************************
Routine   : FreeMeATransArray"
Input  par: TransArray *Tr (pointer to TransArray)
            int xsize      (xsize of array)
Output par: none
Function  : Frees a TransArray structure.
***************************************|***************************************/

 void FreeMeATransArray3D(Transformation ****Tr,int xsize,int ysize)
  {
   register unsigned int i,j;

   if (Tr==NULL) ErrorHandler(NULL_POINTER,"FreeMeATransArray3D with null pointer");
   for (i=0;i<xsize;i++)
    {
     for (j=0;i<ysize;j++) free(Tr[i][j]);
     free(Tr[i]);
    }
   free(Tr);
  }

/**************************************|****************************************
Routine   : GimmeAParameter"
Input  par: none
Output par: Parameter * (pointer to Parameter)
Function  : Allocates a Parameter structure. No initializing.
***************************************|***************************************/

 Parameter *GimmeAParameter(void)
  {
   Parameter *p=(Parameter *)malloc(sizeof(Parameter));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAParameter not able to allocate structure");
   return p;
  }

/**************************************|****************************************
Routine   : FreeMeAParameter"
Input  par: Parameter *p (pointer to Parameter)
Output par: none
Function  : Frees a Parameter structure.
***************************************|***************************************/

 void FreeMeAParameter(Parameter *p)
  {
   if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAParameter with null pointer");
   free(p);
  }

/**************************************|****************************************
Routine   : GimmeABitamap"
Input  par: int xsize (x size of bitmap)
            int ysize (y size of bitmap)
Output par: BitMap *  (pointer to BitMap)
Function  : Allocates a BitMap structure of size x,y. Initialize XSize=x
            YSize=y  Map->Gfx array  ImgType=type
            Bitmap image is initialized to 0'oes.
***************************************|***************************************/

 BitMap *GimmeABitMap(int xsize, int ysize, int type)
  {
   int i;
   BitMap *Gfx;
   unsigned char **Array;

   Gfx=(BitMap *) malloc(sizeof(BitMap));
   if (Gfx==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap not able to allocate structure");

   Array=(unsigned char **) calloc(xsize,sizeof(unsigned char *));
   if (Array==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap not able to allocate structure");
   for (i=0;i<xsize;i++)
    {
     Array[i]=(unsigned char *) calloc(ysize,sizeof(unsigned char));
     if (Array[i]==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap not able to allocate structure");
    }
   Gfx->Map=Array;  /* initialize */
   Gfx->XSize=xsize;
   Gfx->YSize=ysize;
   Gfx->ImgType=type;

   return Gfx;
  }

/**************************************|****************************************
Routine   : FreeMeABitMap"
Input  par: BitMap *Bm (pointer to BitMap)
Output par: none
Function  : Frees a BitMap structure.
***************************************|***************************************/

 void FreeMeABitMap(BitMap *Bm)
  {
   register int i;
   if (Bm==NULL) ErrorHandler(NULL_POINTER,"FreeMeABitMap with null pointer");

   for(i=0;i<Bm->XSize;i++) free(Bm->Map[i]);
   free(Bm->Map);
   free(Bm);
  }


 ListNode *GimmeAListNode(void)
  {
   ListNode *p=(ListNode *)malloc(sizeof(ListNode));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAListNode not able to allocate structure");
   p->Info=0;
   p->Domain=NULL; /* initialize */
   p->Next=NULL; /* initialize */
   p->Pred=NULL;

   return p;
  }


 BitMap3D *GimmeABitMap3D(int xsize, int ysize, int zsize, int type)
  {
   register int i,j;
   BitMap3D *Gfx;
   unsigned char ***Array;

   Gfx=(BitMap3D *) malloc(sizeof(BitMap3D));
   if (Gfx==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");

   Array=(unsigned char ***) calloc(xsize,sizeof(unsigned char **));
   if (Array==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
   for (i=0;i<xsize;i++)
    {
     Array[i]=(unsigned char **) calloc(ysize,sizeof(unsigned char*));
     if (Array[i]==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
     for (j=0;j<ysize;j++)
      {
       Array[i][j]=(unsigned char *) calloc(zsize,sizeof(unsigned char));
       if (Array[i][j]==NULL)
       ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
      }
    }
   Gfx->Map=Array;   /* initialize */
   Gfx->XSize=xsize;
   Gfx->YSize=ysize;
   Gfx->ZSize=zsize;
   Gfx->ImgType=type;

   return Gfx;
  }

/**************************************|****************************************
Routine   : FreeMeABitMap3D"
Input  par: BitMap3D *Bm (pointer to BitMap3D)
Output par: none
Function  : Frees a BitMap3D structure.
***************************************|***************************************/

 void FreeMeABitMap3D(BitMap3D *Bm)
  {
   register int i,j;
   if (Bm==NULL) ErrorHandler(NULL_POINTER,"FreeMeABitMap3D with null pointer");

   for(i=0;i<Bm->XSize;i++)
    {
     for(j=0;j<Bm->YSize;j++) free(Bm->Map[i][j]);
     free(Bm->Map[i]);
    }
   free(Bm->Map);
   free(Bm);
  }


 void FreeMeAListNode(ListNode *El)
  {
   if (El==NULL) ErrorHandler(NULL_POINTER,"FreeMeAListNode with null pointer");
   free(El);
  }

 void FreeMeAList(ListNode *LP)
  {
   ListNode *tmp2,*tmp=LP,*Start=LP;
   if (LP==NULL) ErrorHandler(NULL_POINTER,"FreeMeAList with null pointer");
   do
    {
     tmp2=tmp;
     tmp=tmp->Next;
     FreeMeAListNode(tmp2);
    }
   while((tmp!=NULL) && (tmp!=Start));
  }

 float *GimmeAFloatArray(int n)
  {
   float *p=(float *)calloc(n,sizeof(float));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAFloatArray not able to allocate structure");
   return p;
  }

 void FreeMeAFloatArray(float *Pa)
  {
   if (Pa==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeAFloatArray with null pointer");
   free(Pa);
  }

 long double *GimmeADoubleArray(int n)
  {
   long double *p=(long double *)calloc(n,sizeof(long double));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeADoubleArray not able to allocate structure");
   return p;
  }

 void FreeMeADoubleArray(double *Pa)
  {
   if (Pa==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeADoubleArray with null pointer");
   free(Pa);
  }

 int *GimmeAIntArray(int n)
  {
   int *p=(int *)calloc(n,sizeof(int));
   if (p==NULL) ErrorHandler(NO_FREE_MEMORY,"GimmeAIntArray not able to allocate structure");
   return p;
  }

 void FreeMeAIntArray(int *Pa)
  {
   if (Pa==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeAIntArray with null pointer");
   free(Pa);
  }

 unsigned int *GimmeAUIntArray(int n)
  {
   unsigned int *p=(unsigned int *)calloc(n,sizeof(unsigned int));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAUIntArray not able to allocate structure");
   return p;
  }

 void FreeMeAUIntArray(unsigned int *Pa)
  {
   if (Pa==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeAUIntArray with null pointer");
   free(Pa);
  }

 long *GimmeALongArray(int n)
  {
   long *p=(long *)calloc(n,sizeof(long));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeALongArray not able to allocate structure");
   return p;
  }

 void FreeMeALongArray(long *Pa)
  {
   if (Pa==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeALongArray with null pointer");
   free(Pa);
  }

 unsigned long *GimmeAULongArray(int n)
  {
   unsigned long *p=(unsigned long *)calloc(n,sizeof(unsigned long));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAULongArray not able to allocate structure");
   return p;
  }

 void FreeMeAULongArray(unsigned long *Pa)
  {
   if (Pa==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeAULongArray with null pointer");
   free(Pa);
  }

 LimboHeader *GimmeALimboHeader(void)
  {
   LimboHeader *p=(LimboHeader *)malloc(sizeof(LimboHeader));
   if (p==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeALimboHeader not able to allocate structure");
   return p;
  }

 void FreeMeALimboHeader(LimboHeader *head)
  {
   if (head==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeALimboHeader with null pointer");
   free(head);
  }


 FeatureSpace *GimmeAFeatureSpace(int dim,int size)
  {
   FeatureSpace *S;

   S=(FeatureSpace *)malloc(sizeof(FeatureSpace));
   if (S==NULL)
   ErrorHandler(NO_FREE_MEMORY,"GimmeAFeatureSpace not able to allocate structure");
   S->Dimension=dim;
   S->Size=size;
   S->GridArray=GimmeAGrid(dim,size);

   return S;
  }

 void FreeMeAFeatureSpace(FeatureSpace *S)
  {
   if (S==NULL) ErrorHandler(NULL_POINTER,"FreeMeAFeatureSpace with null pointer");

   if (S->GridArray!=NULL) FreeMeAGrid(S->GridArray,S->Dimension,S->Size);
   free(S);
  }

 Grid *GimmeAGrid(int dim,int size)
  {
   Grid *G=NULL;
   GridTerm *GT;
   register int i;

   if (dim>0)
    {
     G=(Grid *)malloc(sizeof(Grid));
     if (G==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeAGrid not able to allocate structure");
     G->Next=(Grid **)calloc(size,sizeof(Grid *));
     if (G->Next==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeAGrid not able to allocate structure");
     for (i=0;i<size;i++) G->Next[i]=GimmeAGrid(dim-1,size);
    }

   if (dim==0)
    {
     GT=(GridTerm *)malloc(sizeof(GridTerm));
     if (GT==NULL)
     ErrorHandler(NO_FREE_MEMORY,"GimmeAGrid not able to allocate structure");
     GT->Class=NULL;
     GT->Count=0;
     G=(Grid *)GT;
    }

   return G;
  }

 void FreeMeAGrid(Grid *G,int Dim,int Size)
  {
   register int i;
   if (G==NULL)
   ErrorHandler(NULL_POINTER,"FreeMeAGrid with null pointer");

   if(Dim>0)
    {
     if (G->Next!=NULL)
     for(i=0;i<Size;i++)
      {
       FreeMeAGrid(G->Next[i],Dim-1,Size);
       free(G->Next[i]);
      }
    }
   else
    {
     if (G->Next!=NULL)
     for(i=0;i<Size;i++) free((GridTerm *)G->Next[i]);
    }
   free(G);
  }